// 初始化聊天历史
var chatHistory = [
    
];
var chatState = 0;

// 发送消息函数
function sendAIMessage(userMessage) {
    if (!userMessage) return;

    // 添加用户消息到聊天记录
    addMessageToChat('主持人', userMessage);

    // 添加用户消息到历史记录
    chatHistory.push({"role": "user", "content": userMessage});

    // 显示AI正在输入
    showTypingIndicator();

    // 使用流式API调用
    streamAPIRequest();
}

// 流式API请求函数
function streamAPIRequest() {
    // 构建请求参数
    const requestData = {
        "model": "qwen2.5:3b",
        "messages": chatHistory,
        "temperature": 1,
        "top_p": 1,
        "stream": true,
        "stream_options": {
            "include_usage": false
        }
    };

    let aiResponse = "";
    let aiMessageElement = null;
    let toolCallDetected = false;
    let currentToolCall = "";

    fetch("http://127.0.0.1:11434/v1/chat/completions", {
        method: "POST",
        headers: {
            "authorization": "Bearer",
            "content-type": "application/json"
        },
        body: JSON.stringify(requestData)
    })
    .then(response => {
        chatState = 1;
        if (!response.ok) {
            chatState = 0;
            throw new Error(`HTTP error! Status: ${response.status}`);
        }

        const reader = response.body.getReader();
        const decoder = new TextDecoder();

        // 移除正在输入的指示器
        removeTypingIndicator();

        // 创建AI消息元素但不添加到DOM中，用于实时更新
        aiMessageElement = $('<div>').addClass('message ai-message');

        return reader.read().then(function processText({done, value}) {
            if (done) {
                // 处理完所有数据
                if (aiResponse.trim()) {
                    // 最终处理消息并添加到DOM
            finalizeAiMessage(aiResponse, aiMessageElement);
            
            // 添加到历史记录
            chatHistory.push({"role": "assistant", "content": aiResponse});
            
            // 检查是否是狼人相关的对话，如果是则添加到狼人对话历史列表
            // 通过检查最近的system prompt是否包含狼人相关内容来判断
            if (window.werewolfDialogues && chatHistory.length >= 3) {
                const lastSystemMessage = chatHistory[chatHistory.length - 3];
                if (lastSystemMessage && lastSystemMessage.role === 'system' && 
                    (lastSystemMessage.content.includes('狼人') || lastSystemMessage.content.includes('身份是'))) {
                    
                    // 查找对应的狼人用户消息
                    const userMessage = chatHistory[chatHistory.length - 2];
                    
                    // 查找与该用户消息匹配的狼人对话条目
                    const matchingEntry = window.werewolfDialogues.find(entry => 
                        entry.role === 'user' && entry.content === userMessage.content
                    );
                    
                    if (matchingEntry) {
                        // 将AI响应添加到狼人对话历史列表
                        window.werewolfDialogues.push({
                            "role": "assistant",
                            "content": aiResponse,
                            "timestamp": new Date().toISOString(),
                            "wolfId": matchingEntry.wolfId,
                            "phase": matchingEntry.phase,
                            "nightSubPhase": matchingEntry.nightSubPhase
                        });
                        
                        // 检查是否有工具调用结果
                        if (aiResponse.includes('tool_use')) {
                            // 如果是狼人选择目标的工具调用，将结果也保存到狼人对话列表
                            const toolUseMatch = aiResponse.match(/\{"name":"wolf_kill","parameters":\{"wolfNo":"(.*?)","targetNo":"(.*?)"\}\}?/);
                            if (toolUseMatch && toolUseMatch.length > 2) {
                                const wolfNo = toolUseMatch[1];
                                const targetNo = toolUseMatch[2];
                                 
                                // 记录狼人选择的目标到狼人对话历史列表
                                window.werewolfDialogues.push({
                                    "role": "system",
                                    "content": `狼人${wolfNo}选择了目标${targetNo}`,
                                    "timestamp": new Date().toISOString(),
                                    "wolfId": wolfNo,
                                    "phase": matchingEntry.phase,
                                    "nightSubPhase": matchingEntry.nightSubPhase
                                });
                                 
                                // 立即调用wolf_kill函数处理选择结果，触发下一个狼人的对话
                                setTimeout(() => {
                                    if (window.wolf_kill) {
                                        window.wolf_kill(wolfNo, targetNo);
                                    }
                                }, 100);
                            }
                        }
                    }
                }
            }
                } else {
                    addMessageToChat('ai', '抱歉，未获取到响应内容。');
                }
                return;
            }

            // 解码获取的数据
            const chunk = decoder.decode(value, {stream: true});
            
            // 分割成多行（每个事件一行）
            const lines = chunk.split('\n');
            
            lines.forEach(line => {
                console.log("line:", line);
                // 过滤空行和非事件流格式的行
                if (line.trim() === '' || !line.startsWith('data: ')) {
                    return;
                }

                try {
                    // 检查是否是[DONE]消息
                    if (line.substring(5).trim() === '[DONE]') {
                        // 处理完所有数据
                        if (aiResponse.trim()) {
                            // 最终处理消息并添加到DOM
                            finalizeAiMessage(aiResponse, aiMessageElement);
                                
                            // 添加到历史记录
                            chatHistory.push({"role": "assistant", "content": aiResponse});
                        } else {
                            addMessageToChat('ai', '抱歉，未获取到响应内容。');
                        }
                        // 结束处理，不再继续读取
                        return;
                    }
                    
                    // 移除前缀并解析JSON
                    const data = JSON.parse(line.substring(5).trim());
                        
                    // 检查是否有finish_reason为stop或length的情况
                    if (data.choices && data.choices.length > 0 && (data.choices[0].finish_reason === 'stop' || data.choices[0].finish_reason === 'length')) {
                        // 处理完所有数据
                        if (aiResponse.trim()) {
                            // 最终处理消息并添加到DOM
                            finalizeAiMessage(aiResponse, aiMessageElement);
                                
                            // 添加到历史记录
                            chatHistory.push({"role": "assistant", "content": aiResponse});
                        } else {
                            addMessageToChat('ai', '抱歉，未获取到响应内容。');
                        }
                        // 结束处理，不再继续读取
                        chatState = 0;
                        return;
                    }
                        
                    // 检查是否有内容
                    if (data.choices && data.choices.length > 0 && data.choices[0].delta.content !== undefined) {
                        const contentChunk = data.choices[0].delta.content;
                            
                        // 累计响应内容
                        aiResponse += contentChunk;
                            
                        // 处理工具调用检测
                        if (!toolCallDetected) {
                            const toolStartIndex = aiResponse.indexOf('<tool_use>');
                            if (toolStartIndex !== -1) {
                                toolCallDetected = true;
                                currentToolCall = contentChunk.substring(toolStartIndex - (aiResponse.length - contentChunk.length));
                            }
                        } else {
                            currentToolCall += contentChunk;
                            const toolEndIndex = currentToolCall.indexOf('</tool_use>');
                            if (toolEndIndex !== -1) {
                                toolCallDetected = false;
                                // 工具调用已完成，处理它
                                const processedToolCall = processToolCall(currentToolCall);
                                    
                                // 替换原始工具调用文本为处理后的HTML
                                const responseWithoutToolCall = aiResponse.replace(currentToolCall, processedToolCall);
                                    
                                // 更新消息显示
                                updateAiMessage(responseWithoutToolCall, aiMessageElement);
                            }
                        }
                            
                        // 如果没有工具调用或者工具调用已处理完成，更新消息显示
                        if (!toolCallDetected) {
                            updateAiMessage(aiResponse, aiMessageElement);
                        }
                    }
                } catch (error) {
                    chatState = 0;
                    console.error('解析流式响应错误:', error);
                }
            });

            // 继续读取
            return reader.read().then(processText);
        });
    })
    .catch(error => {
        chatState = 0;
        // 移除正在输入的指示器
        removeTypingIndicator();
        
        // 显示错误信息
        addMessageToChat('ai', `请求失败: ${error.message}\n请确保Ollama服务已启动并在127.0.0.1:11434端口运行。`);
        console.error('API请求失败:', error);
    });
}

// 获取函数参数名称的辅助函数
function getParamNames(func) {
    try {
        // 将函数转换为字符串
        const funcStr = func.toString();
        
        // 提取函数参数部分
        const paramsMatch = funcStr.match(/function\s*[^(]*\(\s*([^)]*)\)/m);
        if (!paramsMatch || !paramsMatch[1]) {
            return [];
        }
        
        // 解析参数名并去除空白
        const paramNames = paramsMatch[1].split(',')
            .map(param => param.trim())
            .filter(param => param.length > 0);
        
        return paramNames;
    } catch (e) {
        console.error('获取函数参数名失败:', e);
        return [];
    }
}

// 处理工具调用的函数
function processToolCall(toolCallText) {
    try {
        // 提取工具名称和参数
        const nameMatch = toolCallText.match(/<name>(.*?)<\/name>/);
        const argsMatch = toolCallText.match(/<arguments>(.*?)<\/arguments>/);
        
        if (nameMatch && argsMatch) {
            const toolName = nameMatch[1];
            const argumentsStr = argsMatch[1];
            let toolJson = "";
            let targetFunction = window[toolName];
            if (typeof targetFunction === 'function') {
                try {
                    // 尝试将argumentsStr解析为JSON对象
                    const argsObj = JSON.parse(argumentsStr);
                    
                    // 获取目标函数的参数数量
                    const argCount = targetFunction.length;
                    
                    if (argCount === 1) {
                        // 如果函数只接受一个参数，直接传递整个参数对象
                        toolJson = targetFunction(argsObj);
                    } else {
                        // 如果函数接受多个参数，尝试从对象中提取参数
                        // 获取函数的参数名
                        const paramNames = getParamNames(targetFunction);
                        
                        if (paramNames && paramNames.length > 0) {
                            // 准备参数数组
                            const params = paramNames.map(name => argsObj[name] || undefined);
                            // 使用动态参数调用函数
                            toolJson = targetFunction.apply(null, params);
                        } else {
                            // 如果无法获取参数名，回退到使用整个对象作为参数
                            toolJson = targetFunction(argsObj);
                        }
                    }
                } catch (e) {
                    // 如果JSON解析失败或调用出错，记录错误并使用原方式调用
                    console.error('函数调用错误:', e);
                    toolJson = targetFunction(argumentsStr);
                }
            } else {
                toolJson = "方法没有找到：" + toolName;
            }
            console.log("工具调用：", toolName, argumentsStr, "结果：", toolJson);
            // 返回处理后的HTML，添加工具调用提示
            return `<div class="tool-use">工具调用中
&lt;tool_use&gt;
&lt;name&gt;${toolName}&lt;/name&gt;
&lt;arguments&gt;${argumentsStr}&lt;/arguments&gt;
&lt;/tool_use&gt;</div>`;
        }
    } catch (error) {
        console.error('处理工具调用错误:', error);
    }
    
    // 如果处理失败，返回原始文本
    return toolCallText;
}

// 更新AI消息显示的函数（流式）
function updateAiMessage(content, messageElement) {
    const chatMessages = $('#chat-messages');
    const now = new Date();
    const timeString = now.getHours().toString().padStart(2, '0') + ':' + 
                        now.getMinutes().toString().padStart(2, '0') + ':' + 
                        now.getSeconds().toString().padStart(2, '0');

    // 清空消息元素
    messageElement.empty();
    
    // 添加内容（支持HTML格式，用于工具调用高亮）
    messageElement.html(content);
    
    // 添加时间戳
    messageElement.append($('<div>').addClass('message-time').text(timeString));

    // 检查消息元素是否已添加到DOM
    if (!messageElement.parent().length) {
        chatMessages.append(messageElement);
    }
    
    // 滚动到底部
    chatMessages.scrollTop(chatMessages[0].scrollHeight);
}

// 最终处理AI消息的函数
function finalizeAiMessage(content, messageElement) {
    const chatMessages = $('#chat-messages');
    const now = new Date();
    const timeString = now.getHours().toString().padStart(2, '0') + ':' + 
                        now.getMinutes().toString().padStart(2, '0') + ':' + 
                        now.getSeconds().toString().padStart(2, '0');

    // 清空消息元素
    messageElement.empty();
    
    // 处理消息内容，提取并高亮显示工具调用
    let processedContent = content;
    const toolUseRegex = /<tool_use>\s*<name>(.*?)<\/name>\s*<arguments>(.*?)<\/arguments>\s*<\/tool_use>/gs;
    let match;
    let toolCalls = [];
    
    while ((match = toolUseRegex.exec(content)) !== null) {
        toolCalls.push({ name: match[1], arguments: match[2] });
    }
    
    // 如果有工具调用，将其单独显示
    if (toolCalls.length > 0) {
        const contentParts = content.split(toolUseRegex);
        
        // 添加普通文本部分
        if (contentParts[0].trim()) {
            messageElement.append($('<div>').text(contentParts[0]));
        }
        
        // 添加每个工具调用
        for (let i = 0; i < toolCalls.length; i++) {
            const toolCall = toolCalls[i];
            const toolElement = $('<div>').addClass('tool-use')
                .text(`<tool_use>\n<name>${toolCall.name}</name>\n<arguments>${toolCall.arguments}</arguments>\n</tool_use>`);
            messageElement.append(toolElement);
            
            // 如果还有普通文本部分，添加它
            if (contentParts[i * 3 + 3] && contentParts[i * 3 + 3].trim()) {
                messageElement.append($('<div>').text(contentParts[i * 3 + 3]));
            }
        }
    } else {
        // 没有工具调用，直接添加内容
        messageElement.text(content);
    }
    
    // 添加时间戳
    messageElement.append($('<div>').addClass('message-time').text(timeString));

    // 检查消息元素是否已添加到DOM
    if (!messageElement.parent().length) {
        chatMessages.append(messageElement);
    }
    
    // 滚动到底部
    chatMessages.scrollTop(chatMessages[0].scrollHeight);
}

    function addMessageToChat(sender, content) {
        const chatMessages = document.getElementById('chat-messages');
        
        // 创建消息容器
        const messageContainer = document.createElement('div');
        messageContainer.classList.add('message-container');
        
        // 创建消息内容区
        const messageElement = document.createElement('div');
        messageElement.classList.add('message');
        
        if (sender === '系统' || sender === 'AI') {
            // 系统或AI消息样式
            messageElement.classList.add(sender === '系统' ? 'system-message' : 'user-message');
            
            if (sender === 'AI' && content.includes('tool_use:')) {
                // 提取工具调用部分
                const toolUseMatch = content.match(/tool_use:\s*([^\n]+)/);
                if (toolUseMatch && toolUseMatch[1]) {
                    const toolUseContent = toolUseMatch[1];
                    
                    // 创建一个特殊的div来显示工具调用
                    const toolCallElement = document.createElement('div');
                    toolCallElement.classList.add('tool-call');
                    toolCallElement.textContent = `工具调用: ${toolUseContent}`;
                    messageElement.appendChild(toolCallElement);
                }
            }
            
            // 添加发送者和内容
            const senderSpan = document.createElement('span');
            senderSpan.classList.add('sender');
            senderSpan.textContent = sender;
            messageElement.appendChild(senderSpan);
            
            const contentNode = document.createTextNode(content);
            messageElement.appendChild(contentNode);
        } else {
            // 玩家消息样式
            messageElement.classList.add('user-message');
            
            // 查找玩家信息
            let playerId = null;
            let playerRole = null;
            let playerIcon = null;
            let playerNumber = null;
            
            // 查找对应的玩家
            if (window.gameState && window.gameState.players) {
                for (let i = 0; i < window.gameState.players.length; i++) {
                    if (window.gameState.players[i].name === sender) {
                        playerId = window.gameState.players[i].id;
                        playerRole = window.gameState.players[i].role;
                        playerNumber = playerId; // 假设玩家ID就是编号
                        break;
                    }
                }
            }
            
            // 获取玩家角色图标
            if (window.roles && playerRole && window.roles[playerRole]) {
                playerIcon = window.roles[playerRole].icon || '👤';
            } else {
                playerIcon = '👤';
            }
            
            // 创建玩家信息区域
            const playerInfo = document.createElement('div');
            playerInfo.classList.add('player-info-header');
            
            const iconSpan = document.createElement('span');
            iconSpan.classList.add('player-icon');
            iconSpan.textContent = playerIcon;
            playerInfo.appendChild(iconSpan);
            
            const numberSpan = document.createElement('span');
            numberSpan.classList.add('player-number');
            numberSpan.textContent = playerNumber ? `[${playerNumber}]` : '';
            playerInfo.appendChild(numberSpan);
            
            const nameSpan = document.createElement('span');
            nameSpan.classList.add('player-name');
            nameSpan.textContent = sender;
            playerInfo.appendChild(nameSpan);
            
            if (playerRole) {
                const roleSpan = document.createElement('span');
                roleSpan.classList.add('player-role-name');
                roleSpan.textContent = `(${playerRole})`;
                playerInfo.appendChild(roleSpan);
            }
            
            // 添加到消息中
            messageElement.appendChild(playerInfo);
            
            const contentDiv = document.createElement('div');
            contentDiv.classList.add('message-content');
            contentDiv.textContent = content;
            messageElement.appendChild(contentDiv);
        }
        
        // 添加时间戳
        const timestamp = document.createElement('span');
        timestamp.classList.add('timestamp');
        const now = new Date();
        timestamp.textContent = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
        messageElement.appendChild(timestamp);
        
        // 将消息添加到容器
        messageContainer.appendChild(messageElement);
        
        // 添加到聊天区域
        chatMessages.appendChild(messageContainer);
        chatMessages.scrollTop = chatMessages.scrollHeight;
    }

// 显示AI正在输入的指示器
function showTypingIndicator() {
    chatState = 2;
    const chatMessages = $('#chat-messages');
    const typingIndicator = $('<div>').attr('id', 'typing-indicator').addClass('typing-indicator');
    
    // 添加三个动画点
    for (let i = 0; i < 3; i++) {
        typingIndicator.append($('<div>').addClass('typing-dot'));
    }
    
    chatMessages.append(typingIndicator);
    chatMessages.scrollTop(chatMessages[0].scrollHeight);
}

// 移除AI正在输入的指示器
function removeTypingIndicator() {
    chatState = 1;
    $('#typing-indicator').remove();
}
